class WebRtc {
  constructor(configuration = null) {
   this.connection = new RTCPeerConnection(configuration);
   this.userMedia = null
  }

  // 获取本地的摄像头麦克风设备
  getUserMedia() {
    return new Promise((resolve, reject) => {
      const constraints = {
        audio: true,
        video: {
          width: {ideal: 320, max: 576}
        }
      }
      navigator.mediaDevices.getUserMedia(constraints)
          // 媒体流
          .then((mediaStream)=>  {
            const videoTracks = mediaStream.getTracks();
            console.log("使用视频设备: " + videoTracks);
            // 媒体流加入到RTCPeerConnection实例中
            videoTracks.forEach(track => {
              this.connection.addTrack(track, mediaStream)
            })
            this.userMedia = mediaStream
            resolve(mediaStream)
          })
          .catch(function(error) {
            console.error('本地视频流错误', error)
            reject(error)
          })
    })
  }


  // srs拉流（播放器）
  SrsRtcPlayerAsync() {
    const __internal = () => {
      return {
        defaultPath: '/rtc/v1/play/',
        prepareUrl: function (webrtcUrl) {
          var urlObject = self.__internal.parse(webrtcUrl);

          // If user specifies the schema, use it as API schema.
          var schema = urlObject.user_query.schema;
          schema = schema ? schema + ':' : window.location.protocol;

          var port = urlObject.port || 1985;
          if (schema === 'https:') {
            port = urlObject.port || 443;
          }

          // @see https://github.com/rtcdn/rtcdn-draft
          var api = urlObject.user_query.play || self.__internal.defaultPath;
          if (api.lastIndexOf('/') !== api.length - 1) {
            api += '/';
          }

          var apiUrl = schema + '//' + urlObject.server + ':' + port + api;
          for (var key in urlObject.user_query) {
            if (key !== 'api' && key !== 'play') {
              apiUrl += '&' + key + '=' + urlObject.user_query[key];
            }
          }
          // Replace /rtc/v1/play/&k=v to /rtc/v1/play/?k=v
          apiUrl = apiUrl.replace(api + '&', api + '?');

          var streamUrl = urlObject.url;

          return {
            apiUrl: apiUrl, streamUrl: streamUrl, schema: schema, urlObject: urlObject, port: port,
            tid: Number(parseInt(new Date().getTime()*Math.random()*100)).toString(16).slice(0, 7)
          };
        },
        parse: function (url) {
          // @see: http://stackoverflow.com/questions/10469575/how-to-use-location-object-to-parse-url-without-redirecting-the-page-in-javascri
          var a = document.createElement("a");
          a.href = url.replace("rtmp://", "http://")
              .replace("webrtc://", "http://")
              .replace("rtc://", "http://");

          var vhost = a.hostname;
          var app = a.pathname.substring(1, a.pathname.lastIndexOf("/"));
          var stream = a.pathname.slice(a.pathname.lastIndexOf("/") + 1);

          // parse the vhost in the params of app, that srs supports.
          app = app.replace("...vhost...", "?vhost=");
          if (app.indexOf("?") >= 0) {
            var params = app.slice(app.indexOf("?"));
            app = app.slice(0, app.indexOf("?"));

            if (params.indexOf("vhost=") > 0) {
              vhost = params.slice(params.indexOf("vhost=") + "vhost=".length);
              if (vhost.indexOf("&") > 0) {
                vhost = vhost.slice(0, vhost.indexOf("&"));
              }
            }
          }

          // when vhost equals to server, and server is ip,
          // the vhost is __defaultVhost__
          if (a.hostname === vhost) {
            var re = /^(\d+)\.(\d+)\.(\d+)\.(\d+)$/;
            if (re.test(a.hostname)) {
              vhost = "__defaultVhost__";
            }
          }

          // parse the schema
          var schema = "rtmp";
          if (url.indexOf("://") > 0) {
            schema = url.slice(0, url.indexOf("://"));
          }

          var port = a.port;
          if (!port) {
            // Finger out by webrtc url, if contains http or https port, to overwrite default 1985.
            if (schema === 'webrtc' && url.indexOf(`webrtc://${a.host}:`) === 0) {
              port = (url.indexOf(`webrtc://${a.host}:80`) === 0) ? 80 : 443;
            }

            // Guess by schema.
            if (schema === 'http') {
              port = 80;
            } else if (schema === 'https') {
              port = 443;
            } else if (schema === 'rtmp') {
              port = 1935;
            }
          }

          var ret = {
            url: url,
            schema: schema,
            server: a.hostname, port: port,
            vhost: vhost, app: app, stream: stream
          };
          self.__internal.fill_query(a.search, ret);

          // For webrtc API, we use 443 if page is https, or schema specified it.
          if (!ret.port) {
            if (schema === 'webrtc' || schema === 'rtc') {
              if (ret.user_query.schema === 'https') {
                ret.port = 443;
              } else if (window.location.href.indexOf('https://') === 0) {
                ret.port = 443;
              } else {
                // For WebRTC, SRS use 1985 as default API port.
                ret.port = 1985;
              }
            }
          }

          return ret;
        },
        fill_query: function (query_string, obj) {
          // pure user query object.
          obj.user_query = {};

          if (query_string.length === 0) {
            return;
          }

          // split again for angularjs.
          if (query_string.indexOf("?") >= 0) {
            query_string = query_string.split("?")[1];
          }

          var queries = query_string.split("&");
          for (var i = 0; i < queries.length; i++) {
            var elem = queries[i];

            var query = elem.split("=");
            obj[query[0]] = query[1];
            obj.user_query[query[0]] = query[1];
          }

          // alias domain for vhost.
          if (obj.domain) {
            obj.vhost = obj.domain;
          }
        }
      }
    }
  }
  // srs推流（视频、广播）

  // request请求
  xmlHttpRequest() {
    return new Promise((resolve, reject) =>  {

    })
  }
}

export default WebRtc


